home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / GRAPHICS / GMSMTH01.ZIP / TESTA.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-24  |  10.0 KB  |  439 lines
  1. /*
  2.  
  3.     testa.c
  4.  
  5.     Internet: alexad3@icebox.iceonline.com
  6.     Copyright 1995, April 14 by Alec Russell, ALL rights reserved
  7.  
  8.     Created - 1993/4/14
  9.  
  10.     A silly little demo of basic tcmgame stuff
  11.     This pre-dates the anim engine - thats why it isn't used.
  12.  
  13.     History:
  14.         New file
  15.  
  16. */
  17.  
  18.  
  19.  
  20.  
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <conio.h>
  24. #include <alloc.h>
  25. #include <dos.h>
  26. #include <time.h>
  27.  
  28. #include <pr2.h>
  29. #include <palette.h>>
  30. #include <readlbm.h>
  31. #include <fstring.h>
  32. #include <g_io.h>
  33. #include <gui.h>
  34. #include <erase.h>
  35. #include <die.h>
  36. #include <gmalloc.h>
  37.  
  38. #include <Xlib_all.h>
  39.  
  40. typedef char far * farptr;
  41.  
  42.  
  43. #define NUMSHPS 6
  44.  
  45. typedef struct
  46.    {
  47.    short width, height;
  48.    short x, y;
  49.    short min_x, max_x, min_y, max_y;
  50.    short dx, dy;
  51.    char far *pbm;
  52.    }
  53. anm_t;
  54.  
  55. typedef struct
  56.    {
  57.    BYTE width, height;
  58.    short x[2], y[2];
  59.    short min_x, max_x, min_y, max_y;
  60.    short x0, y0;
  61.    short dx, dy;
  62.    }
  63. shift_t;
  64.  
  65.  
  66. // move the backgound pic, then draw a black rect to cover the edge
  67. // moved from
  68. /* ---------------------- move_rect() --------------------- June 13,1993 */
  69. void move_rect(shift_t *s)
  70. {
  71.    short dx, dy;
  72.  
  73.    s->x0+=s->dx;
  74.    s->y0+=s->dy;
  75.  
  76.    if ( s->x0 < s->min_x )
  77.       {
  78.       s->dx*=-1;
  79.       s->x0=s->min_x;
  80.       }
  81.    else
  82.       {
  83.       if ( s->x0 > s->max_x )
  84.          {
  85.          s->dx*=-1;
  86.          s->x0=s->max_x;
  87.          }
  88.       }
  89.  
  90.    if ( s->y0 < s->min_y )
  91.       {
  92.       s->dy*=-1;
  93.       s->y0=s->min_y;
  94.       }
  95.    else
  96.       {
  97.       if ( s->y0 > s->max_y )
  98.          {
  99.          s->dy*=-1;
  100.          s->y0=s->max_y;
  101.          }
  102.       }
  103.  
  104.    x_shift_rect(s->x[page], s->y[page], s->x[page]+s->width,
  105.                s->y[page]+s->height, s->x0, s->y0, HiddenPageOffs);
  106.  
  107.    dx=s->x0 - s->x[page];
  108.    dy=s->y0 - s->y[page];
  109.  
  110.    if ( dx > 0 )
  111.       {
  112.       /* moved right */
  113.       if ( dy > 0 )
  114.          {
  115.          /* moved down */
  116.          x_rect_fill(s->x[page], s->y[page],
  117.                      s->x0, s->y[page] + s->height, HiddenPageOffs, 0);
  118.          x_rect_fill(s->x0, s->y[page],
  119.                      s->x[page] + s->width, s->y0 + 1, HiddenPageOffs, 0);
  120.          }
  121.       else
  122.          {
  123.          if ( dy < 0 )
  124.             {
  125.             /* moved up */
  126.             x_rect_fill(s->x[page], s->y[page],
  127.                         s->x[page] + dx, s->y0 + s->height, HiddenPageOffs, 0);
  128.             x_rect_fill(s->x[page], s->y0 + s->height,
  129.                         s->x[page] + s->width, s->y[page] + s->height, HiddenPageOffs, 0);
  130.             }
  131.          else
  132.             {
  133.             /* no y move */
  134.             x_rect_fill(s->x[page], s->y0,
  135.                         s->x[page] + dx, s->y0 + s->height, HiddenPageOffs, 0);
  136.             }
  137.          }
  138.       }
  139.    else
  140.       {
  141.       if ( dx < 0 )
  142.          {
  143.          /* moved left */
  144.          if ( dy > 0 )
  145.             {
  146.             /* moved down */
  147.             x_rect_fill(s->x0 + s->width, s->y[page],
  148.                         s->x[page] + s->width, s->y0 + s->height, HiddenPageOffs, 0);
  149.             x_rect_fill(s->x[page], s->y[page],
  150.                         s->x0 + s->width, s->y0, HiddenPageOffs, 0);
  151.             }
  152.          else
  153.             {
  154.             if ( dy < 0 )
  155.                {
  156.                /* moved up */
  157.                x_rect_fill(s->x0 + s->width, s->y[page],
  158.                            s->x[page] + s->width, s->y[page] + s->height, HiddenPageOffs, 0);
  159.                x_rect_fill(s->x[page], s->y0 + s->height,
  160.                            s->x0 + s->width, s->y[page] + s->height, HiddenPageOffs, 0);
  161.                }
  162.             else
  163.                {
  164.                /* no y move */
  165.                x_rect_fill(s->x0 + s->width, s->y0,
  166.                            s->x[page] + s->width, s->y0 + s->height, HiddenPageOffs, 0);
  167.                }
  168.             }
  169.          }
  170.       else
  171.          {
  172.          /* no x move */
  173.          if ( dy > 0 )
  174.             {
  175.             /* moved down */
  176.             x_rect_fill(s->x0, s->y[page],
  177.                         s->x0 + s->width, s->y0, HiddenPageOffs, 0);
  178.             }
  179.          else
  180.             {
  181.             if ( dy < 0 )
  182.                {
  183.                /* moved up */
  184.                x_rect_fill(s->x0, s->y0 + s->height,
  185.                            s->x0 + s->width, s->y[page] + s->height, HiddenPageOffs, 0);
  186.                }
  187.             }
  188.          }
  189.       }
  190.  
  191.    s->x[page]=s->x0;
  192.    s->y[page]=s->y0;
  193.  
  194. }
  195.  
  196.  
  197. /* ---------------------- main() ------------------------- April 28,1993 */
  198. void main(void)
  199. {
  200.    int x, y, done, count, single=0, delay=0;
  201.    unsigned int i;
  202.    event_t event;
  203.    shift_t shift;
  204.    unsigned char far *bitmap;
  205.    unsigned long t1, t2, t3, t4;
  206.    anm_t anm[NUMSHPS];
  207.    char temp[20];
  208.  
  209.    randomize();
  210.    init_xmode_video();
  211.    init_mem_list();
  212.    /* set palette */
  213. pr2("loading palette");
  214.    if ( load_palette("small.pal", palette) )
  215.       {
  216.       die("error getting palette");
  217.       }
  218.  
  219.    setvgapalette(palette);
  220.  
  221.    /* draw background */
  222. pr2("load smallneb");
  223.    bitmap=far_load("smallneb.pbm");
  224.    if ( bitmap )
  225.       {
  226.       shift.width=*bitmap;
  227.       shift.width<<=2;         // pbm widths are in bytes not pixels 
  228.       shift.height=*(bitmap+1);
  229.       x=(360 - shift.width) / 2;
  230.       y=(240 - shift.height) / 2;
  231.       shift.x[0]=shift.x[1]=shift.x0=x;
  232.       shift.y[0]=shift.y[1]=shift.y0=y;
  233.       x_put_pbm(x,y, HiddenPageOffs, bitmap);
  234.       x_page_flip(0,0);
  235.       x_put_pbm(x,y, HiddenPageOffs, bitmap);
  236.       x_page_flip(0,0);
  237.       shift.dx=4;
  238.       shift.dy=4;
  239.       shift.min_x=0;
  240.       shift.min_y=0;
  241.       shift.max_x=ScrnLogicalPixelWidth - shift.width;
  242.       shift.max_x|=3;
  243.       shift.max_x-=3;
  244.       shift.max_y=ScrnLogicalHeight - shift.height;
  245.  
  246.       gfree(bitmap, "bitmap");
  247.       }
  248.    else
  249.       {
  250.       die("error getting small neb");
  251.       }
  252.  
  253.  
  254.    /* loads mouse also */
  255. pr2("init events and load mouse");
  256.    init_events("crshair.cbm");  // this must be AFTER init_xmode_video()
  257.  
  258.    /* init anm shapes */
  259.    for ( i=0; i < NUMSHPS; i++ )
  260.       {
  261.       sprintf(temp, "shp%d.cbm", i);
  262.       bitmap=far_load(temp);
  263.       if ( bitmap == NULL )
  264.          {
  265.          die("ERROR opening %s", temp);
  266.          }
  267.  
  268.       anm[i].width=*bitmap;
  269.       anm[i].height=*(bitmap+1);
  270.  
  271.       do
  272.          {
  273.          anm[i].dx=4-random(8);
  274.          anm[i].dy=4-random(8);
  275.          }
  276.       while ( anm[i].dx == 0 && anm[i].dx == 0 );
  277.       anm[i].x=20 + random(150);
  278.       anm[i].y=20 + random(120);
  279.       anm[i].min_x=0;
  280.       anm[i].min_y=0;
  281.       anm[i].max_x=ScrnLogicalPixelWidth - anm[i].width;
  282.       anm[i].max_y=ScrnLogicalHeight - anm[i].height;
  283.       anm[i].pbm=bitmap+2;
  284.       }
  285.  
  286.    /* set aside mem etc.. for 12 erase rects, not to exceed 9k */
  287.    init_gb_erase(12, 9000);
  288.    page=0;
  289.  
  290.    x=mouse_x;
  291.    y=mouse_y;
  292.  
  293.  
  294.    count=100;
  295.    t1=TICKS;
  296.    done=0;
  297.  
  298.    while ( !done )
  299.       {
  300.       if ( single )
  301.          {
  302.          while ( !get_event(&event) )
  303.             {
  304.             if ( event.type == E_KEY && event.sub_type == E_UP )
  305.                {
  306.                if ( event.d2 == 27 )
  307.                   done=1;
  308.  
  309.                if ( event.d2 == 's' )
  310.                   single=1;
  311.  
  312.                if ( event.d2 == 'c' )
  313.                   single=0;
  314.  
  315.                if ( event.d2 == '-' )
  316.                   if ( delay )
  317.                      --delay;
  318.  
  319.                if ( event.d2 == '+' )
  320.                      ++delay;
  321.                }
  322.             }
  323.          }
  324.       else
  325.          {
  326.          if ( get_event(&event) )
  327.             {
  328.             if ( event.type == E_KEY && event.sub_type == E_UP )
  329.                {
  330.                if ( event.d2 == 27 )
  331.                   done=1;
  332.  
  333.                if ( event.d2 == 's' )
  334.                   single=1;
  335.  
  336.                if ( event.d2 == 'c' )
  337.                   single=0;
  338.  
  339.                if ( event.d2 == '-' )
  340.                   if ( delay )
  341.                      --delay;
  342.  
  343.                if ( event.d2 == '+' )
  344.                      ++delay;
  345.                }
  346.             }
  347.          }
  348.  
  349.       /* erase old stuff */
  350.       draw_erase_rects(&(gb_h[page]));
  351.  
  352.       move_rect(&shift); // move the nebula via vmem to vmem memcpys
  353.  
  354.       /* draw anms */
  355.       for ( i=0; i < NUMSHPS; i++ )
  356.          {
  357.          anm[i].x+=anm[i].dx;
  358.          if ( anm[i].x < anm[i].min_x )
  359.             {
  360.             anm[i].x=anm[i].min_x;
  361.             anm[i].dx*=-1;
  362.             }
  363.          else
  364.             {
  365.             if ( anm[i].x > anm[i].max_x )
  366.                {
  367.                anm[i].x=anm[i].max_x;
  368.                anm[i].dx*=-1;
  369.                }
  370.             }
  371.  
  372.          anm[i].y+=anm[i].dy;
  373.          if ( anm[i].y < anm[i].min_y )
  374.             {
  375.             anm[i].y=anm[i].min_y;
  376.             anm[i].dy*=-1;
  377.             }
  378.          else
  379.             {
  380.             if ( anm[i].y > anm[i].max_y )
  381.                {
  382.                anm[i].y=anm[i].max_y;
  383.                anm[i].dy*=-1;
  384.                }
  385.             }
  386.  
  387.          add_erase_rect(&(gb_h[page]), anm[i].x,anm[i].y, anm[i].width,
  388.                         anm[i].height);
  389.          x_put_cbitmap(anm[i].x,anm[i].y, HiddenPageOffs, anm[i].pbm);
  390.          }
  391.  
  392.  
  393.       /* draw the mouse */
  394.       gui_draw_mouse();
  395.  
  396.       x_page_flip(0,0);
  397.       page= page ? 0 : 1;
  398.  
  399.       if ( delay )
  400.          {
  401.          if ( delay > 300 )
  402.             delay=300;
  403.  
  404.          t3=TICKS;
  405.          t3+=delay;
  406.          t4=TICKS;
  407.          while ( t4 < t3 )
  408.             {
  409.             t4=TICKS;
  410.             pr2("t3 %lu t4 %lu", t3, t4);
  411.             }
  412.          }
  413.  
  414.       --count;
  415.       if ( count == 0 )
  416.          {
  417.          t2=TICKS;
  418.          t2-=t1;
  419.          t2=1860 / t2;
  420.          pr2("%lu frames per second t1 %lu", t2, t1);
  421.          count=100;
  422.          t1=TICKS;
  423.          }
  424.       }
  425.  
  426.    deinit_gb_erase();
  427.  
  428.    for ( i=0; i < NUMSHPS; i++ )
  429.       gfree(anm[i].pbm-2, "anm");
  430.  
  431.    deinit_events();
  432.  
  433.    deinit_xmode_video();
  434. }
  435.  
  436.  
  437. /* ------------------------------ EOF -------------------------------- */
  438.  
  439.